Flattening CLUBB's grid: allocations by any name, bounds by component, generics by arity - #27

…ad; a stub under control flow is a stub block

calc_pressure declares thvm(ngrdcol, gr%nzt): a dummy sized by a component
of the object it takes. The flat signature spells that component's flat
name, an argument of the adapter, and the plan carries the component as an
input whether or not the body reads it -- also when another object's
allocation names it (sponge_layer_damping's profile, sized by gr%nzm).
Every dummy's type is read before the objects are walked so the reference
resolves whichever order they come in.

Skx_func(..., Skw_zm) into a sibling: the caller's storage is passed in and
returned, so the caller reads the actual as well as writing it. The
companion table now says which positions are buffers, and the read/write
scope reads them, the rule it already applied to its own subprograms.

if ( stats%l_sample ) then / call stats_update(...) / end if is a
framework stub under a condition. The condition is read on both sides and
the only disagreement is the stub's actuals; the block is waived like a
bare stub, and the verdict names the calls.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…ate state left to its module, ungated means not sampled

An object passed to a sibling through a generic (zt2zm_api over
grid_class's specifics) was not followed, so the adapter built a record
missing the components the specific reads. A generic is followed into
every specific; the union is what the adapter carries.

An allocation sized by the allocating routine's dummy
(coef_wp4_implicit(1:ngrdcol,1:nz)) is spelled by the planned
subprogram's dummy of the same name, an argument of the adapter.

A module variable the module keeps private (error_code's
clubb_debug_level) reaches no use statement, so no adapter sets it; both
sides run with the module's default and the plan records it under
left_to_module instead of failing.

A subprogram the operator declared ungated is not sampled by the
bit-exact gate either: the declaration says the reference cannot be held
on generated inputs, and rcm_sat_adj proves it by error-stopping the run.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…rsion guard is a stack

Following every specific with the caller's positional actuals mapped the
object onto whichever dummy sat at that position -- zm_min for the
one-level specific -- and the specific the call actually reaches was then
skipped, because a nested follow had marked it visited first. The
specifics whose argument count fits the call are followed (the exact
count when any matches), and a key is released when its follow returns:
the set guards against cycles, it is not a memo.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…ct is read off what the translation returned; a translated error stop is a failed comparison

CLUBB's constants_clubb declares ep = Rd / Rv over two real parameters.
The fold's rule -- an initializer with no real literal is integer
arithmetic throughout -- made it zero, and every unit reading ep1 or ep2
computed NaN. The resolver now records each constant's declared base
type, the fold types a name by it, and both renderers carry the
environment along in dependency order; nrk = runge_kutta_type / 10 stays 4.

The Python flat adapter read a written component off the record it built
from the inputs even when the dummy was intent(out) and the translation
returned a new object (sponge_layer_damping's profile): it now rebinds to
the returned object first.

A translated bare error stop raises SystemExit, which the bit-exact gate
let through and which ended the run with no report; it is now a
comparison that could not be made, named as such.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

CLUBB's lscale_width_vert_avg searches with do k_avg_upper = k, ...; if
(...) exit; end do and integrates up to k_avg_upper. On completion Fortran
leaves the index one step past the end, m1 + n * m3; Python's for leaves
the last value, and the integral ran one level short -- a NaN on one side
in wp23_term_splat_lhs. For a loop whose index some later statement of the
subprogram names, the emitter adds a for-else that sets the completion
value; an EXIT is a break and skips it, as Fortran keeps the exit value.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

gfortran's inlined SUM is a loop in element order; np.sum pairs its terms
and rounds differently -- CLUBB's vertical_integral drifted 12 ULP on 3
of 7770 points. _f_vsum, beside _f_vdot, walks the array in Fortran order
or along the named axis, and the intrinsic table points SUM at it.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…ned; the corpus re-baselined

An else on every loop whose variable any later statement names put one on
most loops of a module -- i and k are reused by the next loop -- and moved
the translator differential from 33 to 130 differing subprograms. A later
DO over the same variable or an assignment to it redefines it first and
closes the question; a later loop's bounds may still read it and count.
The differential is at 45, every one of the twelve new differences an
intended class: an array-valued .or. spelled |, SUM through _f_vsum, the
completion value on a search loop.

The corpus, re-run on this branch: no unit regresses; csplines, fitpack and
slsqp_core have fewer read/write disagreements; numfor's sorting reaches
the bit-exact gate for the first time (its specifics are private behind a
public generic) and exposes a bare use-imported constant in a local
parameter, issue #28.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…s the run owns

A character component (err_info%err_header) has no flat spelling and the
physics reads it only to print: left at the object's default, under
left_to_module. A derived-type module variable declared in a list over
several lines (the four sponge settings) is found on the module record
when the one-line pattern misses it. An allocation sized by the allocating
routine's dummy when the planned subprogram has none of that name
(coef_wp4_implicit(1:ngrdcol,1:nz) under advance_wp2_wp3, which takes
nzm and nzt) becomes an integer argument of the adapter, extent_args,
which the recorder writes from size() and the sampled gate sizes like any
scalar an array's dims name. Every advance_* plan of CLUBB is usable on
this.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…es it

CLUBB passes ngrdcol as a dummy of every subroutine the recorder probes;
a local of the same name was a second declaration, and gfortran said so
forty times.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

CLUBB continues its calls as a, b, & ! In on every line: the comment after
the ampersand left a blank the joiner did not strip, and the probe carried
& into its argument list.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

CLUBB allocates its scalar-tracer coefficients only when sclr_dim > 0;
under bomex it is 0, and reshape of an unallocated component faulted the
probed run after three dumps. An allocatable or pointer component is
recorded inside allocated()/associated(), as a zero-extent record
otherwise, and the extent argument taken from its size() is zero when it
was never allocated.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…eads and writes nothing

The read/write scope marked whatever sat at a union of positions as
written when a call reached a sibling's generic whose specifics differ in
arity: CLUBB's tridiag_solve and zm2zt_api marked nzt, l_implemented and
gr. The companion table now carries each specific with its argument
count, and the scope picks the one the actuals fit.

A name use-imported from a stubbed module is a call the translation
answers with a stub -- pass, for stats_update -- so the source side no
longer counts its actuals: stats_tmp and the budget names were reads only
that side saw.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

The first cut put every name imported from a stubbed module into the
externals table, and a bare name in that table is not a read on the source
side: every constant of constants_clubb -- a stub and a table of constants
-- became a read only the target saw. The frontend now asks the stub
module's own record which imports are procedures (an absent stub is taken
at its import list), and hands the list to the translation, whose protocol
lists them as procedures so a call to a stand-in function is a call and not
a read of its name.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…left off

The companion table said which positions a call writes and left the
reading to 'everything else', so an INOUT actual -- lhs, rhs, err_info into
CLUBB's band_solve -- was written and not read on the source side. Each
entry now says what the caller reads: IN, INOUT, UNKNOWN and a buffer OUT.
And a specific of a generic fits a call whose actuals fall between its
required and its total count, since an optional dummy may be left off.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

call band_solve( ..., solut, rcond = rcond ) (CLUBB): bound by position the
keyword fell on the dummy before it and was counted a read; the companion
table now carries the dummies' names and the scope binds a keyword actual
by name, as it does for a callee of the module itself.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…ank-picked specifics, stubbed calls raise in place

Found by replaying CLUBB's advance_* solvers on bomex recordings:

* dump-replay's parser took only numbers: a logical ``T``/``F`` header
  (l_implemented) was no value, and a zero-extent component (scalar
  tracers under sclr_dim = 0) vanished with its empty body. Both are
  values now.
* The recorder wrote what the objects received; the plain OUT/INOUT
  dummies (wp2, wp3, mono_flux_limiter's low_lev_effect) are outputs too.
* Two specifics of one arity (tridiag_solve with its optional rcond and
  the multiple-rhs one without) were picked by count; the ranks of the
  bare-name actuals decide, so an IN logical is no longer scored written.
* A component name on an OUT actual (``pdf_params%chi_1``) was counted a
  read of a variable of that name; the tidier answer the pipeline's test
  kept as a documented disagreement is now the answer on both sides.
* A call to a procedure of a stubbed module that no statement stub
  answers (lapack_band_solvex on CLUBB's LAPACK path) deferred its whole
  block, condition and LU branch included, so the candidate raised on the
  path the run takes. It raises on its own line now.
* ``max(2, edsclr_dim)`` sizing a local is a bound Python can spell; a
  comma in a bound is legal inside max/min alone.
* The flat-plan module lookup tolerated a missing record (mypy).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

``call inner( x, y, rc = rc )`` where ``rc`` is the caller's own optional
OUT was rendered ``want_rc=True``: present in the callee on every call.
CLUBB's xm_wpxp_solve hands ``rcond = rcond`` to band_solve, whose
``present(rcond)`` branch is the LAPACK diagnostic path -- taken, on the
replay, on every call the run made without rcond. The presence is the
caller's own sentinel for an optional OUT and ``is not None`` for an
optional IN.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

The source side of the read/write gate scored call solve( ..., rc = rc )
as a write of the caller's own optional rc; the translation spells the
callee's present(rc) as the caller's want_rc sentinel, a read. Both
sides now count the read, for a sibling's procedure (companion externals
carry the optional OUT positions) and for one of this module.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…sion over a constructor is a value (#26)

* The flat plan followed only the caller's own dummies into callees. A
  module-state object passed whole to a derived-type dummy -- CLUBB's
  advance_xm_wpxp hands sponge_layer_damping's profile to sponge_damp_xm,
  which reads ``profile%tau_sponge_damp`` -- was left to the module, and
  the replay found it unallocated. It is followed under the callee's
  dummy now, so its components come back under the state's own name.
  A derived-type state variable is no longer listed as left to the
  module: it is the objects path's business.
* ``100._core_rknd * (/ ... /)`` as a local parameter (#26, saturation and
  pdf_closure's hybrid-PDF path): the token pass rendered a bare
  constructor and handed anything around one to the parser, whose
  literals were never hoisted. Each constructor is rendered where it
  stands and the rest goes through the token pass, elementwise.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

The declaration carries the reason -- CLUBB's sponge initializer leaves
the levels below the layer undefined on both sides -- and the replay
reported it, then compared heap contents against np.empty anyway.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

No unit regresses; numfor's genrand goes from 7 to 3 disagreeing blocks and
slsqp from 12 to 8 (the component-name and handed-on-optional rules).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

The comparison loop takes main's: a translated ERROR STOP or an IndexError
on a draw is a draw the subprogram does not take, redrawn. This branch's
recorded-sample branch, zero-value return and declared-ungated skip sit
beside it.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

Against main's own baseline no unit regresses; slsqp goes from 15 to 7
disagreeing blocks of the same 106 checked.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

cpp leaves blank lines where an #ifdef stood inside CLUBB's
advance_clubb_core call; the probe took one for the end of the statement.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

CLUBB's advance_clubb_core passes thlm2T_in_K_api( ... ) -- a generic
over a scalar and a 2-D specific -- as an actual to sat_mixrat_liq_api.
Ranked scalar without looking, the outer generic matched no specific, its
block was deferred, and a deferred block takes the whole subprogram out of
the gate. A non-elemental function's rank is its declared result's.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…eftover CYCLE is delegated

CLUBB's interpolators cycle from inside an IF in a DO loop. The lowering
passed the continue through into a lax.cond branch -- a SyntaxError that
took the whole emitted module down. The loop body's continuation now moves
into the branches that do not cycle, before the fori_loop lowering; what
that cannot fold, and every break, delegates the subprogram to the host.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

The anchor unpacks _out[k] by position; an object's outputs are bound by
component and left their slot out, so advance_clubb_core's
err_info = _out[10] pointed past the list.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

… its guard

advance_clubb_core calls numerical_check's parameterization check under
clubb_at_least_debug_level_api(2), false with statistics off; the check
takes character arguments and its port leaves it on the host. The call
stays the host's under its trace-time guard (a stand-in's function of
constants is a static test), is never traced while the guard holds, fails
by name if it ever does, and the note names it. Refusing the whole step
for a check that never runs was the alternative.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…and-in does

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

The branch pruning took any expression statement for a log line the
anchor had left as a string and dropped the branch; a bare call -- a
procedure the port left on the host -- went with it, silently. Only
pass and a bare constant are inert.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…guard too

advance_clubb_core's parameterization check takes gr and err_info, so the
call reaches the flat-callee rewrite, which refused when the companion's
port had no kernel for it; the same host-call policy applies there.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

The unpacks that follow a call the port left on the host read the
anchor's _out under the same guard; the elided-buffer entry of an earlier
call must not answer for them.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…mmy is absent

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

After a statement that may have returned, _guard_after_returns wrapped
each following statement in its own `if not _ret`. A call whose result
lands in the _out buffer (never a carry) was then separated from its
unpacks by a lax.cond with no carried effects, and the kernel fell back
to the host. Wrap the rest of the block once instead, recursively, so
the buffer and its unpacks share a branch. Loop-return test gains an
elemental two-output call after the returning loop.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

A kernel takes a dummy object apart into components, but its body may
still hand the object whole to something on the host: a framework
stand-in's query on it, a host-kept check under its guard. The name was
never bound in the kernel (UnboundLocalError on the first such use, in
the whole-step port). Rebuild it once at entry from the components, the
way the NumPy flat wrapper does before its call; absent optionals stay
None so present() stays false.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

- a loop whose body lowered to nothing (statistics sampling dropped by
  its stand-in) is dropped, not refused for carrying nothing
- a logical scalar dummy is static under jit: a configuration switch,
  whose dead branch is never traced
- a named or computed stride (a grid's direction, +-1 at run time):
  trips counted by the runtime's _f_trips, the index remapped
- an output the anchor discards (_ = _out[k]) is dropped from the
  elided buffer instead of refused for having no actual
- an optional object the caller leaves out is absent in the callee:
  None in its component slots, its outputs dropped; a call that leaves
  out every (optional) object still reaches the flat function
- a callee's extent argument (an allocatable component sized by an
  allocating routine's dummy) is the caller's own extent argument for
  that axis, else that axis of the caller's component

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

- a break inside a lowered loop is a flag the loop carries: set where
  the break was, it guards the rest of that trip and every later one;
  the DO variable's value at the exit is kept (int32) and rebound after
  the loop; a for-else (the DO ran to completion) runs under the flag
  inverted, its completion value cast to the index's dtype
- static loops scan over int32 indices (Fortran's default integer)
  instead of fori_loop's default-int scan, so a store of the index into
  an integer local or dummy keeps its dtype across a lax.cond
- a subprogram of the module the port could not emit, called from one
  it can, stays on the host (_host.<name>) under the anchor's guard and
  is named in the notes' host_calls, instead of delegating its caller
  and the callers above it; build_module returns those calls
- _lo_n/_st_n hoisted stride bounds are never carries

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

A slice whose bounds trace (the loop index, through locals assigned
k -+ dir * n in scope) but whose length does not becomes the index
lo + arange(trips) * step -- a gather of static length at a traced
offset, a scatter when stored -- with the trip count the runtime's
_f_trips over static atoms, a Python int at trace time. The mask rules
keep the slices whose length depends on a traced bound.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

Sequence association: the anchor spells a 2-d right-hand side handed to
a solver declared over three axes as np.reshape(rhs, (n, m, 1),
order='F'). The kernel's output for that dummy is reshaped to the
array's own shape, the same order, and rebinds it -- a reshape is no
store target, and the anchor's copy-out spelling does not change that.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

A debug print under a level check, statistics under their switch: the
arms lower to nothing and the static Python if was emitted with no
body, a SyntaxError that took the whole emitted module down. Nothing in
both arms is no branch; nothing in one arm is pass.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

iipdf_type == _mod.IIPDF_ADG1: pdf_closure picks its PDF by a constant
of model_flags spelled through the module alias. The static-test
predicate (and the tree's static-expression one) took only the bare
upper-case spelling; the dispatch was a lax.cond chain, every arm
traced, and the arm the run never takes carried a host driver's record
object into the cond. Static now, the dead arm is never traced.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…s fallback

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

The expression mapping spells .not./.and./.or. as jnp.logical_*; under
jit those stage a constant into a tracer that no Python if can
convert (interpolation's .not. l_quintic_poly_interp took the whole
step down). The Python form of a static branch is now spelled with
Python's not/and/or, _f_concrete decides on the leaves (the
comparisons, the names), and the static predicate sees through the
mapped calls so a negated static comparison is static too.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

… are its lowered stores

A DO WHILE under an IF inside a DO (interpolation's grid search): the
exit flag is a carry of the enclosing cond and needs a value before the
branch, at the top of the function like the goto-region flags, with the
one beside the loop resetting it on entry. And the loop's carries are
what its lowered body stores: a subscript store is a store to its base
only once lowered, and an inner loop's break flag and kept index are
the body's own.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

…ried by enclosing loops

advance_helper's window search: a DO with an EXIT under an IF inside
the column loop. The flag and kept index initialized beside their loop
were carries of the enclosing cond with no value before the branch;
they now start at the top of the function (False, index 0) and every
loop enclosing a store of them carries them.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

A DO variable's completion value, max(0, (ub - lb) // step), traces
when the bounds do (an inner loop over the outer index): Python's max
on a tracer is a boolean conversion. _f_pymax/_f_pymin keep Python
scalars Python (a static bound stays static) and fold tracers with
jnp.maximum/minimum.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

jax.numpy has no erf; the math-to-jnp mapping spelled jnp.erf for the
anchor's scalar math.erf (CLUBB's cloud fraction). Both spellings now
reach _f_verf/_f_verfc, which import jax.scipy.special.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd

advance_xm_wpxp counts its right-hand sides under switches and a local
derived from them, then sizes its solver arrays by the count. A local
whose stores are all trace-time expressions -- at the top level or
under branches decided at trace time, logical forms included -- is
concrete: the tree tells the backend on a marker it strips, its
branches are Python ifs, its stores are never strengthened to jnp
scalars and are spelled with Python logic, and zeros((n, nrhs)) sees a
Python int. Logical scalar dummies are static in the tree as in the
backend.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cne4hrGgYqhTMzVgzJtXYd